#include "script.h"

#include <string>
#include <ctime>

#pragma warning(disable : 4244 4305) // double <-> float conversions

Vehicle cargoplaneVeh,
cutterVeh,
annihilatorVeh,
skyliftVeh,
speedo2Veh,
mesa3Veh,
boxville3Veh,
cargobob2Veh,
fixterVeh,
police4Veh,
pony2Veh,
handlerVeh,
policebVeh,
dune2Veh,
ztypeVeh,
jb700Veh,
stingerVeh,
stingergtVeh,
khamelionVeh,
hotknifeVeh,
fbiVeh,
tornado4Veh,
mowerVeh,
rumpo2Veh,
sovereignVeh,
carbonrsVeh,
marshallVeh,
blimpVeh,
police2Veh,
stockadeVeh,
riotVeh,
policetVeh,
tvtrailerVeh,
paradiseVeh,
predatorVeh,
sheriff2Veh,
btypeVeh,
miljetVeh,
aseaVeh,
asea2Veh,
burrito5Veh,
emperor3Veh,
elegy2Veh,
prangerVeh,
mesa2Veh,
policeold1Veh,
policeold2Veh,
sadler2Veh,
stockade3Veh,
tractor3Veh,
rancherxl2Veh;

int cargoplaneSpawned = 0,
cutterSpawned = 0,
annihilatorSpawned = 0,
skyliftSpawned = 0,
speedo2Spawned = 0,
mesa3Spawned = 0,
boxville3Spawned = 0,
cargobob2Spawned = 0,
fixterSpawned = 0,
police4Spawned = 0,
pony2Spawned = 0,
handlerSpawned = 0,
policebSpawned = 0,
dune2Spawned = 0,
ztypeSpawned = 0,
jb700Spawned = 0,
stingerSpawned = 0,
stingergtSpawned = 0,
khamelionSpawned = 0,
hotknifeSpawned = 0,
fbiSpawned = 0,
tornado4Spawned = 0,
mowerSpawned = 0,
rumpo2Spawned = 0,
sovereignSpawned = 0,
carbonrsSpawned = 0,
marshallSpawned = 0,
blimpSpawned = 0,
police2Spawned = 0,
stockadeSpawned = 0,
riotSpawned = 0,
policetSpawned = 0,
tvtrailerSpawned = 0,
paradiseSpawned = 0,
predatorSpawned = 0,
sheriff2Spawned = 0,
btypeSpawned = 0,
miljetSpawned = 0,
aseaSpawned = 0,
asea2Spawned = 0,
burrito5Spawned = 0,
emperor3Spawned = 0,
elegy2Spawned = 0,
prangerSpawned = 0,
mesa2Spawned = 0,
policeold1Spawned = 0,
policeold2Spawned = 0,
sadler2Spawned = 0,
stockade3Spawned = 0,
tractor3Spawned = 0,
rancherxl2Spawned;

int asea2CanSpawn = 0,
burrito5CanSpawn = 0,
emperor3CanSpawn = 0,
mesa2CanSpawn = 0,
policeold1CanSpawn = 0,
policeold2CanSpawn = 0,
sadler2CanSpawn = 0,
stockade3CanSpawn = 0,
tractor3CanSpawn = 0,
rancherxl2CanSpawn;

int mesa2SpawnDistance,
asea2SpawnDistance,
burrito5SpawnDistance,
emperor3SpawnDistance,
policeold1SpawnDistance,
policeold2SpawnDistance,
sadler2SpawnDistance,
stockade3SpawnDistance,
tractor3SpawnDistance,
rancherxl2SpawnDistance;

void update()
{
	Ped playerPed = PLAYER::PLAYER_PED_ID();
	Vehicle veh = PED::GET_VEHICLE_PED_IS_USING(playerPed);
	Vector3 position = ENTITY::GET_ENTITY_COORDS(playerPed, 1);

	/////////////////////////////////////////////////////////////////////////////////////////////
	/*BOOL xxxExist = ENTITY::DOES_ENTITY_EXIST(xxxVeh);
	DWORD xxx = GAMEPLAY::GET_HASH_KEY("xxx");
	int xxxSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(x, x, x, position.x, position.y, position.z, 0);

	if (xxxSpawnDistance < 1000)
	{
	if (xxxSpawned == 0)
	{
	STREAMING::REQUEST_MODEL(xxx);
	while (!STREAMING::HAS_MODEL_LOADED(xxx))
	WAIT(0);
	xxxVeh = VEHICLE::CREATE_VEHICLE(xxx, x, x, x, 0.0, 1, 1);
	ENTITY::SET_ENTITY_HEADING(xxxVeh, x);
	VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(xxxVeh);
	xxxSpawned += 1;
	}
	}

	Vector3 xxxVehPosition = ENTITY::GET_ENTITY_COORDS(xxxVeh, 1);
	int xxxVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(xxxVehPosition.x, xxxVehPosition.y, xxxVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(xxxVeh, 0))
	{
	ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&xxxVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, xxxVeh, 0) && xxxVehDistance > 1000)
	{
	ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&xxxVeh);
	}
	if (xxxSpawnDistance > 1000 && xxxVehDistance > 1000)
	{
	if (xxxSpawned == 1)
	{
	ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&xxxVeh);
	xxxSpawned -= 1;
	}
	}*///template
	/////////////////////////////////////////////////////////////////////////////////////////////

	BOOL cargoplaneExist = ENTITY::DOES_ENTITY_EXIST(cargoplaneVeh);
	DWORD cargoplane = GAMEPLAY::GET_HASH_KEY("cargoplane");
	int cargoplaneSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-1430.27f, -2668.88f, 19.38f, position.x, position.y, position.z, 0);

	if (cargoplaneSpawnDistance < 1000)
	{
		if (cargoplaneSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(cargoplane);
			while (!STREAMING::HAS_MODEL_LOADED(cargoplane))
				WAIT(0);
			cargoplaneVeh = VEHICLE::CREATE_VEHICLE(cargoplane, -1430.27f, -2668.88f, 13.38f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(cargoplaneVeh, 240.14f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(cargoplaneVeh);
			cargoplaneSpawned += 1;
		}
	}

	Vector3 cargoplaneVehPosition = ENTITY::GET_ENTITY_COORDS(cargoplaneVeh, 1);
	int cargoplaneVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(cargoplaneVehPosition.x, cargoplaneVehPosition.y, cargoplaneVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(cargoplaneVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&cargoplaneVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, cargoplaneVeh, 0) && cargoplaneVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&cargoplaneVeh);
	}
	if (cargoplaneSpawnDistance > 1000 && cargoplaneVehDistance > 1000)
	{
		if (cargoplaneSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&cargoplaneVeh);
			cargoplaneSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL cutterExist = ENTITY::DOES_ENTITY_EXIST(cutterVeh);
	DWORD cutter = GAMEPLAY::GET_HASH_KEY("cutter");
	int cutterSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(66.37f, -774.79f, 17.31f, position.x, position.y, position.z, 0);

	if (cutterSpawnDistance < 1000)
	{
		if (cutterSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(cutter);
			while (!STREAMING::HAS_MODEL_LOADED(cutter))
				WAIT(0);
			cutterVeh = VEHICLE::CREATE_VEHICLE(cutter, 66.37f, -774.79f, 17.31f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(cutterVeh, 136.12f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(cutterVeh);
			cutterSpawned += 1;
		}
	}

	Vector3 cutterVehPosition = ENTITY::GET_ENTITY_COORDS(cutterVeh, 1);
	int cutterVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(cutterVehPosition.x, cutterVehPosition.y, cutterVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(cutterVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&cutterVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, cutterVeh, 0) && cutterVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&cutterVeh);
	}
	if (cutterSpawnDistance > 1000 && cutterVehDistance > 1000)
	{
		if (cutterSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&cutterVeh);
			cutterSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL annihilatorExist = ENTITY::DOES_ENTITY_EXIST(annihilatorVeh);
	DWORD annihilator = GAMEPLAY::GET_HASH_KEY("annihilator");
	int annihilatorSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(2512.20f, -340.75f, 117.92f, position.x, position.y, position.z, 0);

	if (annihilatorSpawnDistance < 1000)
	{
		if (annihilatorSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(annihilator);
			while (!STREAMING::HAS_MODEL_LOADED(annihilator))
				WAIT(0);
			annihilatorVeh = VEHICLE::CREATE_VEHICLE(annihilator, 2512.20f, -340.75f, 117.92f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(annihilatorVeh, 317.31f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(annihilatorVeh);
			annihilatorSpawned += 1;
		}
	}

	Vector3 annihilatorVehPosition = ENTITY::GET_ENTITY_COORDS(annihilatorVeh, 1);
	int annihilatorVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(annihilatorVehPosition.x, annihilatorVehPosition.y, annihilatorVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(annihilatorVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&annihilatorVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, annihilatorVeh, 0) && annihilatorVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&annihilatorVeh);
	}
	if (annihilatorSpawnDistance > 1000 && annihilatorVehDistance > 1000)
	{
		if (annihilatorSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&annihilatorVeh);
			annihilatorSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL skyliftExist = ENTITY::DOES_ENTITY_EXIST(skyliftVeh);
	DWORD skylift = GAMEPLAY::GET_HASH_KEY("skylift");
	int skyliftSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-539.57f, -2804.50f, 7.83f, position.x, position.y, position.z, 0);

	if (skyliftSpawnDistance < 1000)
	{
		if (skyliftSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(skylift);
			while (!STREAMING::HAS_MODEL_LOADED(skylift))
				WAIT(0);
			skyliftVeh = VEHICLE::CREATE_VEHICLE(skylift, -539.57f, -2804.50f, 4.83f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(skyliftVeh, 166.94f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(skyliftVeh);
			skyliftSpawned += 1;
		}
	}

	Vector3 skyliftVehPosition = ENTITY::GET_ENTITY_COORDS(skyliftVeh, 1);
	int skyliftVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(skyliftVehPosition.x, skyliftVehPosition.y, skyliftVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(skyliftVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&skyliftVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, skyliftVeh, 0) && skyliftVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&skyliftVeh);
	}
	if (skyliftSpawnDistance > 1000 && skyliftVehDistance > 1000)
	{
		if (skyliftSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&skyliftVeh);
			skyliftSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL speedo2Exist = ENTITY::DOES_ENTITY_EXIST(speedo2Veh);
	DWORD speedo2 = GAMEPLAY::GET_HASH_KEY("speedo2");
	int speedo2SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-1315.83f, -1263.96f, 4.31f, position.x, position.y, position.z, 0);

	if (speedo2SpawnDistance < 1000)
	{
		if (speedo2Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(speedo2);
			while (!STREAMING::HAS_MODEL_LOADED(speedo2))
				WAIT(0);
			speedo2Veh = VEHICLE::CREATE_VEHICLE(speedo2, -1315.83f, -1263.96f, 4.31f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(speedo2Veh, 19.04f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(speedo2Veh);
			speedo2Spawned += 1;
		}
	}

	Vector3 speedo2VehPosition = ENTITY::GET_ENTITY_COORDS(speedo2Veh, 1);
	int speedo2VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(speedo2VehPosition.x, speedo2VehPosition.y, speedo2VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(speedo2Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&speedo2Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, speedo2Veh, 0) && speedo2VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&speedo2Veh);
	}
	if (speedo2SpawnDistance > 1000 && speedo2VehDistance > 1000)
	{
		if (speedo2Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&speedo2Veh);
			speedo2Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL mesa3Exist = ENTITY::DOES_ENTITY_EXIST(mesa3Veh);
	DWORD mesa3 = GAMEPLAY::GET_HASH_KEY("mesa3");
	int mesa3SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(446.73f, -3073.87f, 5.84f, position.x, position.y, position.z, 0);

	if (mesa3SpawnDistance < 1000)
	{
		if (mesa3Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(mesa3);
			while (!STREAMING::HAS_MODEL_LOADED(mesa3))
				WAIT(0);
			mesa3Veh = VEHICLE::CREATE_VEHICLE(mesa3, 446.73f, -3073.87f, 5.84f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(mesa3Veh, 307.46f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(mesa3Veh);
			mesa3Spawned += 1;
		}
	}

	Vector3 mesa3VehPosition = ENTITY::GET_ENTITY_COORDS(mesa3Veh, 1);
	int mesa3VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(mesa3VehPosition.x, mesa3VehPosition.y, mesa3VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(mesa3Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&mesa3Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, mesa3Veh, 0) && mesa3VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&mesa3Veh);
	}
	if (mesa3SpawnDistance > 1000 && mesa3VehDistance > 1000)
	{
		if (mesa3Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&mesa3Veh);
			mesa3Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL boxville3Exist = ENTITY::DOES_ENTITY_EXIST(boxville3Veh);
	DWORD boxville3 = GAMEPLAY::GET_HASH_KEY("boxville3");
	int boxville3SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(3531.36f, 3758.88f, 29.82f, position.x, position.y, position.z, 0);

	if (boxville3SpawnDistance < 1000)
	{
		if (boxville3Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(boxville3);
			while (!STREAMING::HAS_MODEL_LOADED(boxville3))
				WAIT(0);
			boxville3Veh = VEHICLE::CREATE_VEHICLE(boxville3, 3531.36f, 3758.88f, 29.82f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(boxville3Veh, 259.64f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(boxville3Veh);
			boxville3Spawned += 1;
		}
	}

	Vector3 boxville3VehPosition = ENTITY::GET_ENTITY_COORDS(boxville3Veh, 1);
	int boxville3VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(boxville3VehPosition.x, boxville3VehPosition.y, boxville3VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(boxville3Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&boxville3Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, boxville3Veh, 0) && boxville3VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&boxville3Veh);
	}
	if (boxville3SpawnDistance > 1000 && boxville3VehDistance > 1000)
	{
		if (boxville3Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&boxville3Veh);
			boxville3Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL cargobob2Exist = ENTITY::DOES_ENTITY_EXIST(cargobob2Veh);
	DWORD cargobob2 = GAMEPLAY::GET_HASH_KEY("cargobob2");
	int cargobob2SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-1214.11f, -1801.33f, 4.36f, position.x, position.y, position.z, 0);

	if (cargobob2SpawnDistance < 1000)
	{
		if (cargobob2Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(cargobob2);
			while (!STREAMING::HAS_MODEL_LOADED(cargobob2))
				WAIT(0);
			cargobob2Veh = VEHICLE::CREATE_VEHICLE(cargobob2, -1214.11f, -1801.33f, 4.36f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(cargobob2Veh, 35.10f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(cargobob2Veh);
			cargobob2Spawned += 1;
		}
	}

	Vector3 cargobob2VehPosition = ENTITY::GET_ENTITY_COORDS(cargobob2Veh, 1);
	int cargobob2VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(cargobob2VehPosition.x, cargobob2VehPosition.y, cargobob2VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(cargobob2Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&cargobob2Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, cargobob2Veh, 0) && cargobob2VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&cargobob2Veh);
	}
	if (cargobob2SpawnDistance > 1000 && cargobob2VehDistance > 1000)
	{
		if (cargobob2Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&cargobob2Veh);
			cargobob2Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL fixterExist = ENTITY::DOES_ENTITY_EXIST(fixterVeh);
	DWORD fixter = GAMEPLAY::GET_HASH_KEY("fixter");
	int fixterSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-622.66f, 241.65f, 81.49f, position.x, position.y, position.z, 0);

	if (fixterSpawnDistance < 1000)
	{
		if (fixterSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(fixter);
			while (!STREAMING::HAS_MODEL_LOADED(fixter))
				WAIT(0);
			fixterVeh = VEHICLE::CREATE_VEHICLE(fixter, -622.66f, 241.65f, 81.49f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(fixterVeh, 87.24f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(fixterVeh);
			fixterSpawned += 1;
		}
	}

	Vector3 fixterVehPosition = ENTITY::GET_ENTITY_COORDS(fixterVeh, 1);
	int fixterVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(fixterVehPosition.x, fixterVehPosition.y, fixterVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(fixterVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&fixterVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, fixterVeh, 0) && fixterVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&fixterVeh);
	}
	if (fixterSpawnDistance > 1000 && fixterVehDistance > 1000)
	{
		if (fixterSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&fixterVeh);
			fixterSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL police4Exist = ENTITY::DOES_ENTITY_EXIST(police4Veh);
	DWORD police4 = GAMEPLAY::GET_HASH_KEY("police4");
	int police4SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(376.96f, -1830.01f, 28.39f, position.x, position.y, position.z, 0);

	if (police4SpawnDistance < 1000)
	{
		if (police4Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(police4);
			while (!STREAMING::HAS_MODEL_LOADED(police4))
				WAIT(0);
			police4Veh = VEHICLE::CREATE_VEHICLE(police4, 376.96f, -1830.01f, 28.39f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(police4Veh, 167.22f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(police4Veh);
			police4Spawned += 1;
		}
	}

	Vector3 police4VehPosition = ENTITY::GET_ENTITY_COORDS(police4Veh, 1);
	int police4VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(police4VehPosition.x, police4VehPosition.y, police4VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(police4Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&police4Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, police4Veh, 0) && police4VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&police4Veh);
	}
	if (police4SpawnDistance > 1000 && police4VehDistance > 1000)
	{
		if (police4Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&police4Veh);
			police4Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL pony2Exist = ENTITY::DOES_ENTITY_EXIST(pony2Veh);
	DWORD pony2 = GAMEPLAY::GET_HASH_KEY("pony2");
	int pony2SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-1155.34f, -1567.54f, 4.21f, position.x, position.y, position.z, 0);

	if (pony2SpawnDistance < 1000)
	{
		if (pony2Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(pony2);
			while (!STREAMING::HAS_MODEL_LOADED(pony2))
				WAIT(0);
			pony2Veh = VEHICLE::CREATE_VEHICLE(pony2, -1155.34f, -1567.54f, 4.21f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(pony2Veh, 34.53f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(pony2Veh);
			pony2Spawned += 1;
		}
	}

	Vector3 pony2VehPosition = ENTITY::GET_ENTITY_COORDS(pony2Veh, 1);
	int pony2VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(pony2VehPosition.x, pony2VehPosition.y, pony2VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(pony2Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&pony2Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, pony2Veh, 0) && pony2VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&pony2Veh);
	}
	if (pony2SpawnDistance > 1000 && pony2VehDistance > 1000)
	{
		if (pony2Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&pony2Veh);
			pony2Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL policebExist = ENTITY::DOES_ENTITY_EXIST(policebVeh);
	DWORD policeb = GAMEPLAY::GET_HASH_KEY("policeb");
	int policebSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-2566.83f, 2313.10f, 32.69f, position.x, position.y, position.z, 0);

	if (policebSpawnDistance < 1000)
	{
		if (policebSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(policeb);
			while (!STREAMING::HAS_MODEL_LOADED(policeb))
				WAIT(0);
			policebVeh = VEHICLE::CREATE_VEHICLE(policeb, -2566.83f, 2313.10f, 32.69f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(policebVeh, 4.16f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(policebVeh);
			policebSpawned += 1;
		}
	}

	Vector3 policebVehPosition = ENTITY::GET_ENTITY_COORDS(policebVeh, 1);
	int policebVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(policebVehPosition.x, policebVehPosition.y, policebVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(policebVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&policebVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, policebVeh, 0) && policebVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&policebVeh);
	}
	if (policebSpawnDistance > 1000 && policebVehDistance > 1000)
	{
		if (policebSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&policebVeh);
			policebSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL handlerExist = ENTITY::DOES_ENTITY_EXIST(handlerVeh);
	DWORD handler = GAMEPLAY::GET_HASH_KEY("handler");
	int handlerSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-419.12f, -2285.27f, 7.79f, position.x, position.y, position.z, 0);

	if (handlerSpawnDistance < 1000)
	{
		if (handlerSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(handler);
			while (!STREAMING::HAS_MODEL_LOADED(handler))
				WAIT(0);
			handlerVeh = VEHICLE::CREATE_VEHICLE(handler, -419.12f, -2285.27f, 7.79f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(handlerVeh, 359.43f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(handlerVeh);
			handlerSpawned += 1;
		}
	}

	Vector3 handlerVehPosition = ENTITY::GET_ENTITY_COORDS(handlerVeh, 1);
	int handlerVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(handlerVehPosition.x, handlerVehPosition.y, handlerVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(handlerVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&handlerVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, handlerVeh, 0) && handlerVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&handlerVeh);
	}
	if (handlerSpawnDistance > 1000 && handlerVehDistance > 1000)
	{
		if (handlerSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&handlerVeh);
			handlerSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL dune2Exist = ENTITY::DOES_ENTITY_EXIST(dune2Veh);
	DWORD dune2 = GAMEPLAY::GET_HASH_KEY("dune2");
	int dune2SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-2115.27f, 3240.27f, 32.27f, position.x, position.y, position.z, 0);

	if (dune2SpawnDistance < 1000)
	{
		if (dune2Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(dune2);
			while (!STREAMING::HAS_MODEL_LOADED(dune2))
				WAIT(0);
			dune2Veh = VEHICLE::CREATE_VEHICLE(dune2, -2115.27f, 3240.27f, 32.27f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(dune2Veh, 59.51f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(dune2Veh);
			dune2Spawned += 1;
		}
	}

	Vector3 dune2VehPosition = ENTITY::GET_ENTITY_COORDS(dune2Veh, 1);
	int dune2VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(dune2VehPosition.x, dune2VehPosition.y, dune2VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(dune2Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&dune2Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, dune2Veh, 0) && dune2VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&dune2Veh);
	}
	if (dune2SpawnDistance > 1000 && dune2VehDistance > 1000)
	{
		if (dune2Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&dune2Veh);
			dune2Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL ztypeExist = ENTITY::DOES_ENTITY_EXIST(ztypeVeh);
	DWORD ztype = GAMEPLAY::GET_HASH_KEY("ztype");
	int ztypeSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-310.70f, 225.91f, 87.32f, position.x, position.y, position.z, 0);

	if (ztypeSpawnDistance < 1000)
	{
		if (ztypeSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(ztype);
			while (!STREAMING::HAS_MODEL_LOADED(ztype))
				WAIT(0);
			ztypeVeh = VEHICLE::CREATE_VEHICLE(ztype, -310.70f, 225.91f, 87.32f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(ztypeVeh, 281.07f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(ztypeVeh);
			ztypeSpawned += 1;
		}
	}

	Vector3 ztypeVehPosition = ENTITY::GET_ENTITY_COORDS(ztypeVeh, 1);
	int ztypeVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(ztypeVehPosition.x, ztypeVehPosition.y, ztypeVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(ztypeVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&ztypeVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, ztypeVeh, 0) && ztypeVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&ztypeVeh);
	}
	if (ztypeSpawnDistance > 1000 && ztypeVehDistance > 1000)
	{
		if (ztypeSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&ztypeVeh);
			ztypeSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL jb700Exist = ENTITY::DOES_ENTITY_EXIST(jb700Veh);
	DWORD jb700 = GAMEPLAY::GET_HASH_KEY("jb700");
	int jb700SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-1175.19f, -506.17f, 35.10f, position.x, position.y, position.z, 0);

	if (jb700SpawnDistance < 1000)
	{
		if (jb700Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(jb700);
			while (!STREAMING::HAS_MODEL_LOADED(jb700))
				WAIT(0);
			jb700Veh = VEHICLE::CREATE_VEHICLE(jb700, -1175.19f, -506.17f, 35.10f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(jb700Veh, 37.21f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(jb700Veh);
			jb700Spawned += 1;
		}
	}

	Vector3 jb700VehPosition = ENTITY::GET_ENTITY_COORDS(jb700Veh, 1);
	int jb700VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(jb700VehPosition.x, jb700VehPosition.y, jb700VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(jb700Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&jb700Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, jb700Veh, 0) && jb700VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&jb700Veh);
	}
	if (jb700SpawnDistance > 1000 && jb700VehDistance > 1000)
	{
		if (jb700Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&jb700Veh);
			jb700Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL stingerExist = ENTITY::DOES_ENTITY_EXIST(stingerVeh);
	DWORD stinger = GAMEPLAY::GET_HASH_KEY("stinger");
	int stingerSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-118.06f, 973.52f, 235.26f, position.x, position.y, position.z, 0);

	if (stingerSpawnDistance < 1000)
	{
		if (stingerSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(stinger);
			while (!STREAMING::HAS_MODEL_LOADED(stinger))
				WAIT(0);
			stingerVeh = VEHICLE::CREATE_VEHICLE(stinger, -118.06f, 973.52f, 235.26f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(stingerVeh, 323.38f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(stingerVeh);
			stingerSpawned += 1;
		}
	}

	Vector3 stingerVehPosition = ENTITY::GET_ENTITY_COORDS(stingerVeh, 1);
	int stingerVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(stingerVehPosition.x, stingerVehPosition.y, stingerVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(stingerVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&stingerVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, stingerVeh, 0) && stingerVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&stingerVeh);
	}
	if (stingerSpawnDistance > 1000 && stingerVehDistance > 1000)
	{
		if (stingerSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&stingerVeh);
			stingerSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL stingergtExist = ENTITY::DOES_ENTITY_EXIST(stingergtVeh);
	DWORD stingergt = GAMEPLAY::GET_HASH_KEY("stingergt");
	int stingergtSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-1524.48f, 82.63f, 56.63f, position.x, position.y, position.z, 0);

	if (stingergtSpawnDistance < 1000)
	{
		if (stingergtSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(stingergt);
			while (!STREAMING::HAS_MODEL_LOADED(stingergt))
				WAIT(0);
			stingergtVeh = VEHICLE::CREATE_VEHICLE(stingergt, -1524.56f, 82.40f, 56.02f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(stingergtVeh, 7.88f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(stingergtVeh);
			stingergtSpawned += 1;
		}
	}

	Vector3 stingergtVehPosition = ENTITY::GET_ENTITY_COORDS(stingergtVeh, 1);
	int stingergtVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(stingergtVehPosition.x, stingergtVehPosition.y, stingergtVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(stingergtVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&stingergtVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, stingergtVeh, 0) && stingergtVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&stingergtVeh);
	}
	if (stingergtSpawnDistance > 1000 && stingergtVehDistance > 1000)
	{
		if (stingergtSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&stingergtVeh);
			stingergtSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL khamelionExist = ENTITY::DOES_ENTITY_EXIST(khamelionVeh);
	DWORD khamelion = GAMEPLAY::GET_HASH_KEY("khamelion");
	int khamelionSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-2295.84f, 376.03f, 173.74f, position.x, position.y, position.z, 0);

	if (khamelionSpawnDistance < 1000)
	{
		if (khamelionSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(khamelion);
			while (!STREAMING::HAS_MODEL_LOADED(khamelion))
				WAIT(0);
			khamelionVeh = VEHICLE::CREATE_VEHICLE(khamelion, -2295.84f, 376.03f, 173.74f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(khamelionVeh, 292.89f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(khamelionVeh);
			khamelionSpawned += 1;
		}
	}

	Vector3 khamelionVehPosition = ENTITY::GET_ENTITY_COORDS(khamelionVeh, 1);
	int khamelionVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(khamelionVehPosition.x, khamelionVehPosition.y, khamelionVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(khamelionVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&khamelionVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, khamelionVeh, 0) && khamelionVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&khamelionVeh);
	}
	if (khamelionSpawnDistance > 1000 && khamelionVehDistance > 1000)
	{
		if (khamelionSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&khamelionVeh);
			khamelionSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL hotknifeExist = ENTITY::DOES_ENTITY_EXIST(hotknifeVeh);
	DWORD hotknife = GAMEPLAY::GET_HASH_KEY("hotknife");
	int hotknifeSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-2180.48f, 4268.38f, 48.40f, position.x, position.y, position.z, 0);

	if (hotknifeSpawnDistance < 1000)
	{
		if (hotknifeSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(hotknife);
			while (!STREAMING::HAS_MODEL_LOADED(hotknife))
				WAIT(0);
			hotknifeVeh = VEHICLE::CREATE_VEHICLE(hotknife, -2180.48f, 4268.38f, 48.40f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(hotknifeVeh, 151.09f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(hotknifeVeh);
			hotknifeSpawned += 1;
		}
	}

	Vector3 hotknifeVehPosition = ENTITY::GET_ENTITY_COORDS(hotknifeVeh, 1);
	int hotknifeVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(hotknifeVehPosition.x, hotknifeVehPosition.y, hotknifeVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(hotknifeVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&hotknifeVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, hotknifeVeh, 0) && hotknifeVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&hotknifeVeh);
	}
	if (hotknifeSpawnDistance > 1000 && hotknifeVehDistance > 1000)
	{
		if (hotknifeSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&hotknifeVeh);
			hotknifeSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL fbiExist = ENTITY::DOES_ENTITY_EXIST(fbiVeh);
	DWORD fbi = GAMEPLAY::GET_HASH_KEY("fbi");
	int fbiSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(176.43f, -688.82f, 32.77f, position.x, position.y, position.z, 0);

	if (fbiSpawnDistance < 1000)
	{
		if (fbiSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(fbi);
			while (!STREAMING::HAS_MODEL_LOADED(fbi))
				WAIT(0);
			fbiVeh = VEHICLE::CREATE_VEHICLE(fbi, 176.43f, -688.82f, 32.77f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(fbiVeh, 337.98f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(fbiVeh);
			fbiSpawned += 1;
		}
	}

	Vector3 fbiVehPosition = ENTITY::GET_ENTITY_COORDS(fbiVeh, 1);
	int fbiVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(fbiVehPosition.x, fbiVehPosition.y, fbiVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(fbiVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&fbiVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, fbiVeh, 0) && fbiVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&fbiVeh);
	}
	if (fbiSpawnDistance > 1000 && fbiVehDistance > 1000)
	{
		if (fbiSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&fbiVeh);
			fbiSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL tornado4Exist = ENTITY::DOES_ENTITY_EXIST(tornado4Veh);
	DWORD tornado4 = GAMEPLAY::GET_HASH_KEY("tornado4");
	int tornado4SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(1973.04f, 3028.37f, 46.76f, position.x, position.y, position.z, 0);

	if (tornado4SpawnDistance < 1000)
	{
		if (tornado4Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(tornado4);
			while (!STREAMING::HAS_MODEL_LOADED(tornado4))
				WAIT(0);
			tornado4Veh = VEHICLE::CREATE_VEHICLE(tornado4, 1973.04f, 3028.37f, 46.76f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(tornado4Veh, 327.86f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(tornado4Veh);
			tornado4Spawned += 1;
		}
	}

	Vector3 tornado4VehPosition = ENTITY::GET_ENTITY_COORDS(tornado4Veh, 1);
	int tornado4VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(tornado4VehPosition.x, tornado4VehPosition.y, tornado4VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(tornado4Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&tornado4Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, tornado4Veh, 0) && tornado4VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&tornado4Veh);
	}
	if (tornado4SpawnDistance > 1000 && tornado4VehDistance > 1000)
	{
		if (tornado4Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&tornado4Veh);
			tornado4Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL mowerExist = ENTITY::DOES_ENTITY_EXIST(mowerVeh);
	DWORD mower = GAMEPLAY::GET_HASH_KEY("mower");
	int mowerSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-1356.06f, 122.44f, 55.68f, position.x, position.y, position.z, 0);

	if (mowerSpawnDistance < 1000)
	{
		if (mowerSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(mower);
			while (!STREAMING::HAS_MODEL_LOADED(mower))
				WAIT(0);
			mowerVeh = VEHICLE::CREATE_VEHICLE(mower, -1356.06f, 122.44f, 55.68f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(mowerVeh, 274.78f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(mowerVeh);
			mowerSpawned += 1;
		}
	}

	Vector3 mowerVehPosition = ENTITY::GET_ENTITY_COORDS(mowerVeh, 1);
	int mowerVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(mowerVehPosition.x, mowerVehPosition.y, mowerVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(mowerVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&mowerVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, mowerVeh, 0) && mowerVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&mowerVeh);
	}
	if (mowerSpawnDistance > 1000 && mowerVehDistance > 1000)
	{
		if (mowerSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&mowerVeh);
			mowerSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL rumpo2Exist = ENTITY::DOES_ENTITY_EXIST(rumpo2Veh);
	DWORD rumpo2 = GAMEPLAY::GET_HASH_KEY("rumpo2");
	int rumpo2SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-515.56f, -295.62f, 35.25f, position.x, position.y, position.z, 0);

	if (rumpo2SpawnDistance < 1000)
	{
		if (rumpo2Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(rumpo2);
			while (!STREAMING::HAS_MODEL_LOADED(rumpo2))
				WAIT(0);
			rumpo2Veh = VEHICLE::CREATE_VEHICLE(rumpo2, -515.56f, -295.62f, 35.25f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(rumpo2Veh, 22.90f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(rumpo2Veh);
			rumpo2Spawned += 1;
		}
	}

	Vector3 rumpo2VehPosition = ENTITY::GET_ENTITY_COORDS(rumpo2Veh, 1);
	int rumpo2VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(rumpo2VehPosition.x, rumpo2VehPosition.y, rumpo2VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(rumpo2Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&rumpo2Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, rumpo2Veh, 0) && rumpo2VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&rumpo2Veh);
	}
	if (rumpo2SpawnDistance > 1000 && rumpo2VehDistance > 1000)
	{
		if (rumpo2Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&rumpo2Veh);
			rumpo2Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL sovereignExist = ENTITY::DOES_ENTITY_EXIST(sovereignVeh);
	DWORD sovereign = GAMEPLAY::GET_HASH_KEY("sovereign");
	int sovereignSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(1702.38f, 3757.66f, 33.83f, position.x, position.y, position.z, 0);

	if (sovereignSpawnDistance < 1000)
	{
		if (sovereignSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(sovereign);
			while (!STREAMING::HAS_MODEL_LOADED(sovereign))
				WAIT(0);
			sovereignVeh = VEHICLE::CREATE_VEHICLE(sovereign, 1702.38f, 3757.66f, 33.83f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(sovereignVeh, 226.28f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(sovereignVeh);
			sovereignSpawned += 1;
		}
	}

	Vector3 sovereignVehPosition = ENTITY::GET_ENTITY_COORDS(sovereignVeh, 1);
	int sovereignVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(sovereignVehPosition.x, sovereignVehPosition.y, sovereignVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(sovereignVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&sovereignVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, sovereignVeh, 0) && sovereignVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&sovereignVeh);
	}
	if (sovereignSpawnDistance > 1000 && sovereignVehDistance > 1000)
	{
		if (sovereignSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&sovereignVeh);
			sovereignSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL carbonrsExist = ENTITY::DOES_ENTITY_EXIST(carbonrsVeh);
	DWORD carbonrs = GAMEPLAY::GET_HASH_KEY("carbonrs");
	int carbonrsSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-1862.60f, -352.83f, 48.76f, position.x, position.y, position.z, 0);

	if (carbonrsSpawnDistance < 1000)
	{
		if (carbonrsSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(carbonrs);
			while (!STREAMING::HAS_MODEL_LOADED(carbonrs))
				WAIT(0);
			carbonrsVeh = VEHICLE::CREATE_VEHICLE(carbonrs, -1862.60f, -352.83f, 48.76f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(carbonrsVeh, 53.14f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(carbonrsVeh);
			carbonrsSpawned += 1;
		}
	}

	Vector3 carbonrsVehPosition = ENTITY::GET_ENTITY_COORDS(carbonrsVeh, 1);
	int carbonrsVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(carbonrsVehPosition.x, carbonrsVehPosition.y, carbonrsVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(carbonrsVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&carbonrsVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, carbonrsVeh, 0) && carbonrsVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&carbonrsVeh);
	}
	if (carbonrsSpawnDistance > 1000 && carbonrsVehDistance > 1000)
	{
		if (carbonrsSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&carbonrsVeh);
			carbonrsSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL marshallExist = ENTITY::DOES_ENTITY_EXIST(marshallVeh);
	DWORD marshall = GAMEPLAY::GET_HASH_KEY("marshall");
	int marshallSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(1003.46f, 2386.72f, 72.51f, position.x, position.y, position.z, 0);

	if (marshallSpawnDistance < 1000)
	{
		if (marshallSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(marshall);
			while (!STREAMING::HAS_MODEL_LOADED(marshall))
				WAIT(0);
			marshallVeh = VEHICLE::CREATE_VEHICLE(marshall, 1003.46f, 2386.72f, 72.51f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(marshallVeh, 59.57f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(marshallVeh);
			marshallSpawned += 1;
		}
	}

	Vector3 marshallVehPosition = ENTITY::GET_ENTITY_COORDS(marshallVeh, 1);
	int marshallVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(marshallVehPosition.x, marshallVehPosition.y, marshallVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(marshallVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&marshallVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, marshallVeh, 0) && marshallVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&marshallVeh);
	}
	if (marshallSpawnDistance > 1000 && marshallVehDistance > 1000)
	{
		if (marshallSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&marshallVeh);
			marshallSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL blimpExist = ENTITY::DOES_ENTITY_EXIST(blimpVeh);
	DWORD blimp = GAMEPLAY::GET_HASH_KEY("blimp");
	int blimpSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(1125.12f, 134.11f, 80.11f, position.x, position.y, position.z, 0);

	if (blimpSpawnDistance < 1000)
	{
		if (blimpSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(blimp);
			while (!STREAMING::HAS_MODEL_LOADED(blimp))
				WAIT(0);
			blimpVeh = VEHICLE::CREATE_VEHICLE(blimp, 1125.12f, 134.11f, 80.11f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(blimpVeh, 148.64f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(blimpVeh);
			blimpSpawned += 1;
		}
	}

	Vector3 blimpVehPosition = ENTITY::GET_ENTITY_COORDS(blimpVeh, 1);
	int blimpVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(blimpVehPosition.x, blimpVehPosition.y, blimpVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(blimpVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&blimpVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, blimpVeh, 0) && blimpVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&blimpVeh);
	}
	if (blimpSpawnDistance > 1000 && blimpVehDistance > 1000)
	{
		if (blimpSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&blimpVeh);
			blimpSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL police2Exist = ENTITY::DOES_ENTITY_EXIST(police2Veh);
	DWORD police2 = GAMEPLAY::GET_HASH_KEY("police2");
	int police2SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-1124.56f, -839.14f, 13.02f, position.x, position.y, position.z, 0);

	if (police2SpawnDistance < 1000)
	{
		if (police2Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(police2);
			while (!STREAMING::HAS_MODEL_LOADED(police2))
				WAIT(0);
			police2Veh = VEHICLE::CREATE_VEHICLE(police2, -1124.56f, -839.14f, 13.02f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(police2Veh, 129.09f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(police2Veh);
			police2Spawned += 1;
		}
	}

	Vector3 police2VehPosition = ENTITY::GET_ENTITY_COORDS(police2Veh, 1);
	int police2VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(police2VehPosition.x, police2VehPosition.y, police2VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(police2Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&police2Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, police2Veh, 0) && police2VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&police2Veh);
	}
	if (police2SpawnDistance > 1000 && police2VehDistance > 1000)
	{
		if (police2Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&police2Veh);
			police2Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL stockadeExist = ENTITY::DOES_ENTITY_EXIST(stockadeVeh);
	DWORD stockade = GAMEPLAY::GET_HASH_KEY("stockade");
	int stockadeSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(58.61f, -573.41f, 31.23f, position.x, position.y, position.z, 0);

	if (stockadeSpawnDistance < 1000)
	{
		if (stockadeSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(stockade);
			while (!STREAMING::HAS_MODEL_LOADED(stockade))
				WAIT(0);
			stockadeVeh = VEHICLE::CREATE_VEHICLE(stockade, 58.61f, -573.41f, 31.23f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(stockadeVeh, 76.03f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(stockadeVeh);
			stockadeSpawned += 1;
		}
	}

	Vector3 stockadeVehPosition = ENTITY::GET_ENTITY_COORDS(stockadeVeh, 1);
	int stockadeVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(stockadeVehPosition.x, stockadeVehPosition.y, stockadeVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(stockadeVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&stockadeVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, stockadeVeh, 0) && stockadeVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&stockadeVeh);
	}
	if (stockadeSpawnDistance > 1000 && stockadeVehDistance > 1000)
	{
		if (stockadeSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&stockadeVeh);
			stockadeSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL riotExist = ENTITY::DOES_ENTITY_EXIST(riotVeh);
	DWORD riot = GAMEPLAY::GET_HASH_KEY("riot");
	int riotSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(2535.74f, -452.63f, 92.71f, position.x, position.y, position.z, 0);

	if (riotSpawnDistance < 1000)
	{
		if (riotSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(riot);
			while (!STREAMING::HAS_MODEL_LOADED(riot))
				WAIT(0);
			riotVeh = VEHICLE::CREATE_VEHICLE(riot, 2535.74f, -452.63f, 92.71f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(riotVeh, 135.32f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(riotVeh);
			riotSpawned += 1;
		}
	}

	Vector3 riotVehPosition = ENTITY::GET_ENTITY_COORDS(riotVeh, 1);
	int riotVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(riotVehPosition.x, riotVehPosition.y, riotVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(riotVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&riotVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, riotVeh, 0) && riotVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&riotVeh);
	}
	if (riotSpawnDistance > 1000 && riotVehDistance > 1000)
	{
		if (riotSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&riotVeh);
			riotSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL policetExist = ENTITY::DOES_ENTITY_EXIST(policetVeh);
	DWORD policet = GAMEPLAY::GET_HASH_KEY("policet");
	int policetSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(380.03f, -1630.71f, 28.47f, position.x, position.y, position.z, 0);

	if (policetSpawnDistance < 1000)
	{
		if (policetSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(policet);
			while (!STREAMING::HAS_MODEL_LOADED(policet))
				WAIT(0);
			policetVeh = VEHICLE::CREATE_VEHICLE(policet, 380.03f, -1630.71f, 28.47f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(policetVeh, 320.94f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(policetVeh);
			policetSpawned += 1;
		}
	}

	Vector3 policetVehPosition = ENTITY::GET_ENTITY_COORDS(policetVeh, 1);
	int policetVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(policetVehPosition.x, policetVehPosition.y, policetVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(policetVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&policetVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, policetVeh, 0) && policetVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&policetVeh);
	}
	if (policetSpawnDistance > 1000 && policetVehDistance > 1000)
	{
		if (policetSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&policetVeh);
			policetSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL tvtrailerExist = ENTITY::DOES_ENTITY_EXIST(tvtrailerVeh);
	DWORD tvtrailer = GAMEPLAY::GET_HASH_KEY("tvtrailer");
	int tvtrailerSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-252.03f, -2104.26, 27.62f, position.x, position.y, position.z, 0);

	if (tvtrailerSpawnDistance < 1000)
	{
		if (tvtrailerSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(tvtrailer);
			while (!STREAMING::HAS_MODEL_LOADED(tvtrailer))
				WAIT(0);
			tvtrailerVeh = VEHICLE::CREATE_VEHICLE(tvtrailer, -252.03f, -2104.26, 27.62f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(tvtrailerVeh, 265.46f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(tvtrailerVeh);
			tvtrailerSpawned += 1;
		}
	}

	Vector3 tvtrailerVehPosition = ENTITY::GET_ENTITY_COORDS(tvtrailerVeh, 1);
	int tvtrailerVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(tvtrailerVehPosition.x, tvtrailerVehPosition.y, tvtrailerVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(tvtrailerVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&tvtrailerVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, tvtrailerVeh, 0) && tvtrailerVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&tvtrailerVeh);
	}
	if (tvtrailerSpawnDistance > 1000 && tvtrailerVehDistance > 1000)
	{
		if (tvtrailerSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&tvtrailerVeh);
			tvtrailerSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL paradiseExist = ENTITY::DOES_ENTITY_EXIST(paradiseVeh);
	DWORD paradise = GAMEPLAY::GET_HASH_KEY("paradise");
	int paradiseSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-1714.08f, -1120.95f, 13.17f, position.x, position.y, position.z, 0);

	if (paradiseSpawnDistance < 1000)
	{
		if (paradiseSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(paradise);
			while (!STREAMING::HAS_MODEL_LOADED(paradise))
				WAIT(0);
			paradiseVeh = VEHICLE::CREATE_VEHICLE(paradise, -1714.08f, -1120.95f, 13.17f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(paradiseVeh, 347.03f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(paradiseVeh);
			paradiseSpawned += 1;
		}
	}

	Vector3 paradiseVehPosition = ENTITY::GET_ENTITY_COORDS(paradiseVeh, 1);
	int paradiseVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(paradiseVehPosition.x, paradiseVehPosition.y, paradiseVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(paradiseVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&paradiseVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, paradiseVeh, 0) && paradiseVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&paradiseVeh);
	}
	if (paradiseSpawnDistance > 1000 && paradiseVehDistance > 1000)
	{
		if (paradiseSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&paradiseVeh);
			paradiseSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL predatorExist = ENTITY::DOES_ENTITY_EXIST(predatorVeh);
	DWORD predator = GAMEPLAY::GET_HASH_KEY("predator");
	int predatorSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-1797.44f, -1229.40f, 0.65f, position.x, position.y, position.z, 0);

	if (predatorSpawnDistance < 1000)
	{
		if (predatorSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(predator);
			while (!STREAMING::HAS_MODEL_LOADED(predator))
				WAIT(0);
			predatorVeh = VEHICLE::CREATE_VEHICLE(predator, -1797.44f, -1229.40f, 0.65f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(predatorVeh, 323.95f);
			//VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(predatorVeh);
			predatorSpawned += 1;
		}
	}

	Vector3 predatorVehPosition = ENTITY::GET_ENTITY_COORDS(predatorVeh, 1);
	int predatorVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(predatorVehPosition.x, predatorVehPosition.y, predatorVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(predatorVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&predatorVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, predatorVeh, 0) && predatorVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&predatorVeh);
	}
	if (predatorSpawnDistance > 1000 && predatorVehDistance > 1000)
	{
		if (predatorSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&predatorVeh);
			predatorSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL sheriff2Exist = ENTITY::DOES_ENTITY_EXIST(sheriff2Veh);
	DWORD sheriff2 = GAMEPLAY::GET_HASH_KEY("sheriff2");
	int sheriff2SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(1868.35f, 3694.74f, 33.29f, position.x, position.y, position.z, 0);

	if (sheriff2SpawnDistance < 1000)
	{
		if (sheriff2Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(sheriff2);
			while (!STREAMING::HAS_MODEL_LOADED(sheriff2))
				WAIT(0);
			sheriff2Veh = VEHICLE::CREATE_VEHICLE(sheriff2, 1868.35f, 3694.74f, 33.29f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(sheriff2Veh, 209.11f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(sheriff2Veh);
			sheriff2Spawned += 1;
		}
	}

	Vector3 sheriff2VehPosition = ENTITY::GET_ENTITY_COORDS(sheriff2Veh, 1);
	int sheriff2VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(sheriff2VehPosition.x, sheriff2VehPosition.y, sheriff2VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(sheriff2Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&sheriff2Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, sheriff2Veh, 0) && sheriff2VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&sheriff2Veh);
	}
	if (sheriff2SpawnDistance > 1000 && sheriff2VehDistance > 1000)
	{
		if (sheriff2Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&sheriff2Veh);
			sheriff2Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL btypeExist = ENTITY::DOES_ENTITY_EXIST(btypeVeh);
	DWORD btype = GAMEPLAY::GET_HASH_KEY("btype");
	int btypeSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-1343.86f, 611.25f, 133.20f, position.x, position.y, position.z, 0);

	if (btypeSpawnDistance < 1000)
	{
		if (btypeSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(btype);
			while (!STREAMING::HAS_MODEL_LOADED(btype))
				WAIT(0);
			btypeVeh = VEHICLE::CREATE_VEHICLE(btype, -1343.86f, 611.25f, 133.20f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(btypeVeh, 95.81f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(btypeVeh);
			btypeSpawned += 1;
		}
	}

	Vector3 btypeVehPosition = ENTITY::GET_ENTITY_COORDS(btypeVeh, 1);
	int btypeVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(btypeVehPosition.x, btypeVehPosition.y, btypeVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(btypeVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&btypeVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, btypeVeh, 0) && btypeVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&btypeVeh);
	}
	if (btypeSpawnDistance > 1000 && btypeVehDistance > 1000)
	{
		if (btypeSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&btypeVeh);
			btypeSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL miljetExist = ENTITY::DOES_ENTITY_EXIST(miljetVeh);
	DWORD miljet = GAMEPLAY::GET_HASH_KEY("miljet");
	int miljetSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-1343.78f, -2689.91f, 15.11f, position.x, position.y, position.z, 0);

	if (miljetSpawnDistance < 1000)
	{
		if (miljetSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(miljet);
			while (!STREAMING::HAS_MODEL_LOADED(miljet))
				WAIT(0);
			miljetVeh = VEHICLE::CREATE_VEHICLE(miljet, -1343.78f, -2689.91f, 15.11f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(miljetVeh, 330.18f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(miljetVeh);
			miljetSpawned += 1;
		}
	}

	Vector3 miljetVehPosition = ENTITY::GET_ENTITY_COORDS(miljetVeh, 1);
	int miljetVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(miljetVehPosition.x, miljetVehPosition.y, miljetVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(miljetVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&miljetVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, miljetVeh, 0) && miljetVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&miljetVeh);
	}
	if (miljetSpawnDistance > 1000 && miljetVehDistance > 1000)
	{
		if (miljetSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&miljetVeh);
			miljetSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL prangerExist = ENTITY::DOES_ENTITY_EXIST(prangerVeh);
	DWORD pranger = GAMEPLAY::GET_HASH_KEY("pranger");
	int prangerSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-589.31f, 5050.89f, 137.69f, position.x, position.y, position.z, 0);

	if (prangerSpawnDistance < 1000)
	{
		if (prangerSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(pranger);
			while (!STREAMING::HAS_MODEL_LOADED(pranger))
				WAIT(0);
			prangerVeh = VEHICLE::CREATE_VEHICLE(pranger, -589.31f, 5050.89f, 137.69f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(prangerVeh, 6.08f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(prangerVeh);
			prangerSpawned += 1;
		}
	}

	Vector3 prangerVehPosition = ENTITY::GET_ENTITY_COORDS(prangerVeh, 1);
	int prangerVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(prangerVehPosition.x, prangerVehPosition.y, prangerVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(prangerVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&prangerVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, prangerVeh, 0) && prangerVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&prangerVeh);
	}
	if (prangerSpawnDistance > 1000 && prangerVehDistance > 1000)
	{
		if (prangerSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&prangerVeh);
			prangerSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL elegy2Exist = ENTITY::DOES_ENTITY_EXIST(elegy2Veh);
	DWORD elegy2 = GAMEPLAY::GET_HASH_KEY("elegy2");
	int elegy2SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(300.28f, -197.15f, 60.88f, position.x, position.y, position.z, 0);

	if (elegy2SpawnDistance < 1000)
	{
		if (elegy2Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(elegy2);
			while (!STREAMING::HAS_MODEL_LOADED(elegy2))
				WAIT(0);
			elegy2Veh = VEHICLE::CREATE_VEHICLE(elegy2, 300.28f, -197.15f, 60.88f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(elegy2Veh, 67.37f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(elegy2Veh);
			elegy2Spawned += 1;
		}
	}

	Vector3 elegy2VehPosition = ENTITY::GET_ENTITY_COORDS(elegy2Veh, 1);
	int elegy2VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(elegy2VehPosition.x, elegy2VehPosition.y, elegy2VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(elegy2Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&elegy2Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, elegy2Veh, 0) && elegy2VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&elegy2Veh);
	}
	if (elegy2SpawnDistance > 1000 && elegy2VehDistance > 1000)
	{
		if (elegy2Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&elegy2Veh);
			elegy2Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	mesa2SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(63.70f, 2785.85f, 57.39f, position.x, position.y, position.z, 0);
	policeold1SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(258.09f, 1690.98f, 235.65f, position.x, position.y, position.z, 0);
	policeold2SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(87.28f, -1242.79f, 28.84f, position.x, position.y, position.z, 0);
	sadler2SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(1398.25f, 1059.26f, 114.08f, position.x, position.y, position.z, 0);
	stockade3SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(920.25f, 50.15f, 80.37f, position.x, position.y, position.z, 0);
	tractor3SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(2170.43f, 5080.33f, 44.65f, position.x, position.y, position.z, 0);
	asea2SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(1331.22f, -1734.61f, 55.70f, position.x, position.y, position.z, 0);
	burrito5SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(771.24f, -1318.16f, 26.04f, position.x, position.y, position.z, 0);
	emperor3SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(54.29f, 6670.33f, 31.43f, position.x, position.y, position.z, 0);
	rancherxl2SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(1685.18f, 6434.37f, 31.96f, position.x, position.y, position.z, 0);
																	
	if (GAMEPLAY::GET_SNOW_LEVEL() > 0)
	{
		if (mesa2SpawnDistance > 1000)
		{
			mesa2CanSpawn = 1;
		}
		if (policeold1SpawnDistance > 1000)
		{
			policeold1CanSpawn = 1;
		}
		if (policeold2SpawnDistance > 1000)
		{
			policeold2CanSpawn = 1;
		}
		if (sadler2SpawnDistance > 1000)
		{
			sadler2CanSpawn = 1;
		}
		if (stockade3SpawnDistance > 1000)
		{
			stockade3CanSpawn = 1;
		}
		if (emperor3SpawnDistance > 1000)
		{
			emperor3CanSpawn = 1;
		}
		if (tractor3SpawnDistance > 1000)
		{
			tractor3CanSpawn = 1;
		}
		if (burrito5SpawnDistance > 1000)
		{
			burrito5CanSpawn = 1;
		}
		if (asea2SpawnDistance > 1000)
		{
			asea2CanSpawn = 1;
		}
		if (rancherxl2SpawnDistance > 1000)
		{
			rancherxl2CanSpawn = 1;
		}
	}
	if (GAMEPLAY::GET_SNOW_LEVEL() == 0.0f)
	{
		asea2CanSpawn = 0,
		burrito5CanSpawn = 0,
		emperor3CanSpawn = 0,
		mesa2CanSpawn = 0,
		policeold1CanSpawn = 0,
		policeold2CanSpawn = 0,
		sadler2CanSpawn = 0,
		stockade3CanSpawn = 0,
		tractor3CanSpawn = 0;
		rancherxl2CanSpawn = 0;
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL mesa2Exist = ENTITY::DOES_ENTITY_EXIST(mesa2Veh);
	DWORD mesa2 = GAMEPLAY::GET_HASH_KEY("mesa2");

	if (mesa2SpawnDistance < 1000 && mesa2CanSpawn == 1)
	{
		if (mesa2Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(mesa2);
			while (!STREAMING::HAS_MODEL_LOADED(mesa2))
				WAIT(0);
			mesa2Veh = VEHICLE::CREATE_VEHICLE(mesa2, 63.70f, 2785.85f, 57.39f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(mesa2Veh, 141.21f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(mesa2Veh);
			mesa2Spawned += 1;
		}
	}

	Vector3 mesa2VehPosition = ENTITY::GET_ENTITY_COORDS(mesa2Veh, 1);
	int mesa2VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(mesa2VehPosition.x, mesa2VehPosition.y, mesa2VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(mesa2Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&mesa2Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, mesa2Veh, 0) && mesa2VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&mesa2Veh);
	}
	if (mesa2SpawnDistance > 1000 && mesa2VehDistance > 1000)
	{
		if (mesa2Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&mesa2Veh);
			mesa2Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL policeold1Exist = ENTITY::DOES_ENTITY_EXIST(policeold1Veh);
	DWORD policeold1 = GAMEPLAY::GET_HASH_KEY("policeold1");

	if (policeold1SpawnDistance < 1000 && policeold1CanSpawn == 1)
	{
		if (policeold1Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(policeold1);
			while (!STREAMING::HAS_MODEL_LOADED(policeold1))
				WAIT(0);
			policeold1Veh = VEHICLE::CREATE_VEHICLE(policeold1, 258.09f, 1690.98f, 235.65f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(policeold1Veh, 125.56f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(policeold1Veh);
			policeold1Spawned += 1;
		}
	}

	Vector3 policeold1VehPosition = ENTITY::GET_ENTITY_COORDS(policeold1Veh, 1);
	int policeold1VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(policeold1VehPosition.x, policeold1VehPosition.y, policeold1VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(policeold1Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&policeold1Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, policeold1Veh, 0) && policeold1VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&policeold1Veh);
	}
	if (policeold1SpawnDistance > 1000 && policeold1VehDistance > 1000)
	{
		if (policeold1Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&policeold1Veh);
			policeold1Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL policeold2Exist = ENTITY::DOES_ENTITY_EXIST(policeold2Veh);
	DWORD policeold2 = GAMEPLAY::GET_HASH_KEY("policeold2");

	if (policeold2SpawnDistance < 1000 && policeold2CanSpawn == 1)
	{
		if (policeold2Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(policeold2);
			while (!STREAMING::HAS_MODEL_LOADED(policeold2))
				WAIT(0);
			policeold2Veh = VEHICLE::CREATE_VEHICLE(policeold2, 87.28f, -1242.79f, 28.84f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(policeold2Veh, 94.45f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(policeold2Veh);
			policeold2Spawned += 1;
		}
	}

	Vector3 policeold2VehPosition = ENTITY::GET_ENTITY_COORDS(policeold2Veh, 1);
	int policeold2VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(policeold2VehPosition.x, policeold2VehPosition.y, policeold2VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(policeold2Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&policeold2Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, policeold2Veh, 0) && policeold2VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&policeold2Veh);
	}
	if (policeold2SpawnDistance > 1000 && policeold2VehDistance > 1000)
	{
		if (policeold2Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&policeold2Veh);
			policeold2Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL sadler2Exist = ENTITY::DOES_ENTITY_EXIST(sadler2Veh);
	DWORD sadler2 = GAMEPLAY::GET_HASH_KEY("sadler2");

	if (sadler2SpawnDistance < 1000 && sadler2CanSpawn == 1)
	{
		if (sadler2Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(sadler2);
			while (!STREAMING::HAS_MODEL_LOADED(sadler2))
				WAIT(0);
			sadler2Veh = VEHICLE::CREATE_VEHICLE(sadler2, 1398.25f, 1059.26f, 114.08f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(sadler2Veh, 233.35f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(sadler2Veh);
			sadler2Spawned += 1;
		}
	}

	Vector3 sadler2VehPosition = ENTITY::GET_ENTITY_COORDS(sadler2Veh, 1);
	int sadler2VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(sadler2VehPosition.x, sadler2VehPosition.y, sadler2VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(sadler2Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&sadler2Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, sadler2Veh, 0) && sadler2VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&sadler2Veh);
	}
	if (sadler2SpawnDistance > 1000 && sadler2VehDistance > 1000)
	{
		if (sadler2Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&sadler2Veh);
			sadler2Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL stockade3Exist = ENTITY::DOES_ENTITY_EXIST(stockade3Veh);
	DWORD stockade3 = GAMEPLAY::GET_HASH_KEY("stockade3");

	if (stockade3SpawnDistance < 1000 && stockade3CanSpawn == 1)
	{
		if (stockade3Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(stockade3);
			while (!STREAMING::HAS_MODEL_LOADED(stockade3))
				WAIT(0);
			stockade3Veh = VEHICLE::CREATE_VEHICLE(stockade3, 920.25f, 50.15f, 80.37f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(stockade3Veh, 329.10f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(stockade3Veh);
			stockade3Spawned += 1;
		}
	}

	Vector3 stockade3VehPosition = ENTITY::GET_ENTITY_COORDS(stockade3Veh, 1);
	int stockade3VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(stockade3VehPosition.x, stockade3VehPosition.y, stockade3VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(stockade3Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&stockade3Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, stockade3Veh, 0) && stockade3VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&stockade3Veh);
	}
	if (stockade3SpawnDistance > 1000 && stockade3VehDistance > 1000)
	{
		if (stockade3Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&stockade3Veh);
			stockade3Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL tractor3Exist = ENTITY::DOES_ENTITY_EXIST(tractor3Veh);
	DWORD tractor3 = GAMEPLAY::GET_HASH_KEY("tractor3");

	if (tractor3SpawnDistance < 1000 && tractor3CanSpawn == 1)
	{
		if (tractor3Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(tractor3);
			while (!STREAMING::HAS_MODEL_LOADED(tractor3))
				WAIT(0);
			tractor3Veh = VEHICLE::CREATE_VEHICLE(tractor3, 2170.43f, 5080.33f, 44.65f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(tractor3Veh, 27.87f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(tractor3Veh);
			tractor3Spawned += 1;
		}
	}

	Vector3 tractor3VehPosition = ENTITY::GET_ENTITY_COORDS(tractor3Veh, 1);
	int tractor3VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(tractor3VehPosition.x, tractor3VehPosition.y, tractor3VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(tractor3Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&tractor3Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, tractor3Veh, 0) && tractor3VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&tractor3Veh);
	}
	if (tractor3SpawnDistance > 1000 && tractor3VehDistance > 1000)
	{
		if (tractor3Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&tractor3Veh);
			tractor3Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL asea2Exist = ENTITY::DOES_ENTITY_EXIST(asea2Veh);
	DWORD asea2 = GAMEPLAY::GET_HASH_KEY("asea2");

	if (asea2SpawnDistance < 1000 && asea2CanSpawn == 1)
	{
		if (asea2Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(asea2);
			while (!STREAMING::HAS_MODEL_LOADED(asea2))
				WAIT(0);
			asea2Veh = VEHICLE::CREATE_VEHICLE(asea2, 1331.22f, -1734.61f, 55.70f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(asea2Veh, 20.81f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(asea2Veh);
			asea2Spawned += 1;
		}
	}

	Vector3 asea2VehPosition = ENTITY::GET_ENTITY_COORDS(asea2Veh, 1);
	int asea2VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(asea2VehPosition.x, asea2VehPosition.y, asea2VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(asea2Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&asea2Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, asea2Veh, 0) && asea2VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&asea2Veh);
	}
	if (asea2SpawnDistance > 1000 && asea2VehDistance > 1000)
	{
		if (asea2Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&asea2Veh);
			asea2Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL burrito5Exist = ENTITY::DOES_ENTITY_EXIST(burrito5Veh);
	DWORD burrito5 = GAMEPLAY::GET_HASH_KEY("burrito5");

	if (burrito5SpawnDistance < 1000 && burrito5CanSpawn == 1)
	{
		if (burrito5Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(burrito5);
			while (!STREAMING::HAS_MODEL_LOADED(burrito5))
				WAIT(0);
			burrito5Veh = VEHICLE::CREATE_VEHICLE(burrito5, 771.24f, -1318.16f, 26.04f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(burrito5Veh, 181.23f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(burrito5Veh);
			burrito5Spawned += 1;
		}
	}

	Vector3 burrito5VehPosition = ENTITY::GET_ENTITY_COORDS(burrito5Veh, 1);
	int burrito5VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(burrito5VehPosition.x, burrito5VehPosition.y, burrito5VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(burrito5Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&burrito5Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, burrito5Veh, 0) && burrito5VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&burrito5Veh);
	}
	if (burrito5SpawnDistance > 1000 && burrito5VehDistance > 1000)
	{
		if (burrito5Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&burrito5Veh);
			burrito5Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL emperor3Exist = ENTITY::DOES_ENTITY_EXIST(emperor3Veh);
	DWORD emperor3 = GAMEPLAY::GET_HASH_KEY("emperor3");

	if (emperor3SpawnDistance < 1000 && emperor3CanSpawn == 1)
	{
		if (emperor3Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(emperor3);
			while (!STREAMING::HAS_MODEL_LOADED(emperor3))
				WAIT(0);
			emperor3Veh = VEHICLE::CREATE_VEHICLE(emperor3, 54.29f, 6670.33f, 31.43f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(emperor3Veh, 154.87f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(emperor3Veh);
			emperor3Spawned += 1;
		}
	}

	Vector3 emperor3VehPosition = ENTITY::GET_ENTITY_COORDS(emperor3Veh, 1);
	int emperor3VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(emperor3VehPosition.x, emperor3VehPosition.y, emperor3VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(emperor3Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&emperor3Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, emperor3Veh, 0) && emperor3VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&emperor3Veh);
	}
	if (emperor3SpawnDistance > 1000 && emperor3VehDistance > 1000)
	{
		if (emperor3Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&emperor3Veh);
			emperor3Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL rancherxl2Exist = ENTITY::DOES_ENTITY_EXIST(rancherxl2Veh);
	DWORD rancherxl2 = GAMEPLAY::GET_HASH_KEY("rancherxl2");

	if (rancherxl2SpawnDistance < 1000 && rancherxl2CanSpawn == 1)
	{
		if (rancherxl2Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(rancherxl2);
			while (!STREAMING::HAS_MODEL_LOADED(rancherxl2))
				WAIT(0);
			rancherxl2Veh = VEHICLE::CREATE_VEHICLE(rancherxl2, 1685.18f, 6434.37f, 31.96f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(rancherxl2Veh, 196.28f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(rancherxl2Veh);
			rancherxl2Spawned += 1;
		}
	}

	Vector3 rancherxl2VehPosition = ENTITY::GET_ENTITY_COORDS(rancherxl2Veh, 1);
	int rancherxl2VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(rancherxl2VehPosition.x, rancherxl2VehPosition.y, rancherxl2VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(rancherxl2Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&rancherxl2Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, rancherxl2Veh, 0) && rancherxl2VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&rancherxl2Veh);
	}
	if (rancherxl2SpawnDistance > 1000 && rancherxl2VehDistance > 1000)
	{
		if (rancherxl2Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&rancherxl2Veh);
			rancherxl2Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
}

void main()
{
	while (true)
	{
		update();
		WAIT(0);
	}
}

void ScriptMain()
{
	srand(GetTickCount());
	main();
}

